#!C:\work\Python27\python.exe
# -*- coding: utf-8 -*-

from openpyxl.workbook import Workbook
from openpyxl.reader.excel import load_workbook

import Tkinter
from Tkinter import *
import tkFileDialog as fd

import os

import time
import datetime

##from collections import defaultdict

from SPARQLWrapper import SPARQLWrapper, JSON, ASK, POST, GET, N3, XML

####muunnettava = " Vaatimus  ja perustelu "
####
####muunnettu = ""
####taulu = muunnettava.split()
####for i in range(0, len(taulu)):
####    muunnettu += taulu[i]+" "
####muunnettu = muunnettu.strip()
####print "."+muunnettu+"."
####
##
##
####<rdf:Description rdf:about=”http://sosmeta.fi/”+ASIAKIRJAN NIMI+”/”+toXMLName(LUKANTAIKENTÄNNIMI)+”>
####
####   // Kaikista luokan kentistä tehdään viittaus nimettömään nodeen: 
####   <rdfs:subClassOf rdf:nodeID="A”+(COUNTER++)"/> 
####
####   // Viittaus seuraavaan kenttään
####   <ccts:hasNext rdf:resource=”http://sosmeta.fi/”+ toXMLName(SeuraavanTietokomponentinTaiKentänNimi)+”/>
####</rdf:Description>
####
####// Kaikista kentistä tehdään nimetön node
####<rdf:Description rdf:nodeID="A+(COUNTER++) ">
####   <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Restriction"/>
####   <owl:onProperty rdf:resource=http://sosmeta.fi/”+ASIAKIRJAN NIMI+”/”+toXMLName(KENTÄNNIMI)+ "/>
####   <owl:maxCardinality rdf:datatype="http://www.w3.org/2001/XMLSchema#nonNegativeInteger">1</owl:maxCardinality>
####</rdf:Description>
####
####// Lisäksi kaikista luokkaviittauksista tuotetaan luokka, eli takaisin alkuun …
##
####taulu = muunnettava.split()
####muunnettava = "vaatimus ja perustelu"
####
####muunnettu = ""
####taulu = muunnettava.split()
####for i in range(0, len(taulu)):
####    isoksi = taulu[i].capitalize()
####    muunnettu += isoksi
##
####print muunnettu


def main():
    ohjelmaLoppuu = False
    ikkuna = Tkinter.Tk()
    ikkuna.withdraw()  #Piilottaa ikkunan(GUI)
    d = fd.askopenfilenames(title="Avaa tiedosto") #Näyttää "avaa-tiedosto"-ikkunan
    if(d == None or d == ""): #Jos "avaa-tiedosto"-ikkunassa painaa näppäintä "Cancel", ohjelma loppuu
        print "Ohjelma suljetaan"
        ohjelmaLoppuu = True
##    d = encoder(d)
    d = str(d)
    d = ikkuna.tk.splitlist(d)
    laskuri = 0

    while(ohjelmaLoppuu == False):
        if(laskuri >= len(d)):
            ohjelmaLoppuu = True
            break

        tiedostopolku = d[laskuri]
        tiedostopolku = tiedostopolku.decode('utf-8')

        index = tiedostopolku.rfind("/", 0, len(tiedostopolku))
        tiedosto = tiedostopolku[index+1:]
        print tiedosto

        wb = load_workbook(tiedostopolku)

        tanaan = datetime.date.today() #Tämänhetkinen päiväys

        #luo tarvittaessa uuden "xmldocs"-kansion uudella päivämäärällä
        if not os.access("xmldocs\\"+str(tanaan), os.F_OK):
            os.makedirs("xmldocs\\"+str(tanaan))
##        if(os.path.exists("xmldocs\\"+str(tanaan)) == False):
##            os.makedirs("xmldocs\\"+str(tanaan))

        #luo uuden Validointiraportti-tiedoston juoksevalla numerolla
        numero = 1
        uusiTiedostoOk = False
        while(uusiTiedostoOk == False):
            if(os.path.isfile("xmldocs\\"+str(tanaan)+"\\"+tiedosto+"_"+str(tanaan)+"_("+str(numero)+").xml") == False):
                handle = open("xmldocs\\"+str(tanaan)+"\\"+tiedosto+"_"+str(tanaan)+"_("+str(numero)+").xml", "a")
                uusiTiedostoOk = True
            else:
               numero += 1

        valilehdet(wb, tiedosto, handle)

        handle.close() #sulkee tiedoston

        os.startfile("xmldocs\\"+str(tanaan)+"\\"+tiedosto+"_"+str(tanaan)+"_("+str(numero)+").xml") #käynnistää luodun tiedoston

        laskuri += 1

#Käy läpi välilehtiä
def valilehdet(wb, tiedosto, handle):
    #Aloittaa xml-dokumentin:
    xmlLisays = ("<?xml version='1.0' encoding='UTF-8'?>\n"
                 "<!--  "+tiedosto+"  -->\n"
                 "<CCTSLibrary>\n")
    xmldoc(xmlLisays, handle)

    stack = []
    valilehti = 0
    valilehtiaYhteensa = len(wb.worksheets)

    while(valilehti < valilehtiaYhteensa):
        ws = wb.worksheets[valilehti]
        valilehdenNimi = str(ws)
        valilehdenNimi = valilehdenNimi.decode('utf-8')

        index1 = valilehdenNimi.find('"', 0, len(valilehdenNimi))
        index2 = valilehdenNimi.rfind('"', 0, len(valilehdenNimi))
        valilehdenNimi = valilehdenNimi[index1+1:index2]

        valilehdenNimi = valilehdenNimi.capitalize()

        print valilehdenNimi

        rivi = ekatarkistus(ws)
        if(rivi == -1):
            valilehti += 1
        else:
            dt = dokunimenTarkistus(ws)
##            dt = str(dt)
            xmlLisays = ("<Document>\n"
                         "      <DocumentName>"+valilehdenNimi+"</DocumentName>\n"
                         "      <DocumentType>"+dt+"</DocumentType>\n"
                         "      <DocumentDefinition>"+dokumaarityksenTarkistus(ws)+"</DocumentDefinition>"
                         )
            xmldoc(xmlLisays, handle)

            tokatarkistus(rivi, ws, stack, handle)

            xmlLisays = ("</Document>")
            xmldoc(xmlLisays, handle)

            valilehti += 1

    #Lopettaa xml-dokumentin:
    xmlLisays = ("</CCTSLibrary>\n"
                 "<!--  Generated by SARVI-palvelu  -->")
    xmldoc(xmlLisays, handle)
    print "Valmis"

##Hakee dokumentin määrityksen.
def dokunimenTarkistus(ws):
    return ws.cell(row = 2, column = 0).value

##Hakee dokumentin määrityksen.
def dokumaarityksenTarkistus(ws):
    palauta = ws.cell(row = 2, column = 8).value
    return str(palauta)

##Lisää html-koodia tiedostoon.
def xmldoc(xmlLisays, handle):
    xmldoc = []
    xmldoc.append(xmlLisays)
    handle.write((" ".join(xmldoc))+"\n")

##Tutkii löytyykö välilehdestä saraketta: "Asiakirjarakenteet".
def ekatarkistus(ws):
    valmis = False
    etsittava = "Asiakirjarakenteet"
    ruutu = None
    rivi = 0
    loytyi = False

    while(valmis == False):
        ruutu = ws.cell(row = rivi, column = 0)
        if(ruutu.value == etsittava):
            loytyi = True
            valmis = True
        else:
            if(rivi < 18000):
                rivi += 1
            else:
                valmis = True
    if(loytyi == True):
        rivi += 1
        return rivi
    else:
        return -1

##Testaa onko annettu rivi tyhjä
def tyhjanRivinHaku(ws, rivi):
    tyhjarivi = True
    sarake = 0
    tiedonesitysmuoto = tiedonEsitysmuotoTarkistus(ws)
    for sarake in range(0, tiedonesitysmuoto):
        if(ws.cell(row = rivi, column = sarake).value != None):
            tyhjarivi = False
        sarake += 1

    return tyhjarivi

##Etsii taulukosta tietyt kentät
def tokatarkistus(rivi, ws, stack, handle):
    sarake = 0
    ruutu = ws.cell(row = rivi, column = sarake)
    lopetus = viimeinenRiviTaulukossa(ws)
    etsittava = "TK "
    edellinensarake = 0
    stack = []
##    akListaA = []
##    akListaB = []
##    akListaC = []
##    akListaD = []
##    akListaE = []
##    akListaF = []
##    akListaG = []
##    lista = []

    ohitettavatLista = [u"Otsikko, vain näyttömuotoon",
                        u"Otsikko",
                        u"Otsikko vain näyttömuotoon",
                        u"otsikko, vain näyttömuotoon",
                        u"otsikko vain näyttömuotoon",
                        u"otsikko, vain näyttömuodossa",
                        u"Otsikko näyttömuotoon",
                        u"Otsikko, näyttömuotoon",
                        u"ei otsikkoa",
                        u"Tyhjä rivi, vain näyttömuotoon",
                        u"tyhjä rivi, vain näyttömuotoon",
                        u"tyhjä rivi vain näyttömuotoon",
                        u"Tyhjä rivi vain näyttömuotoon",
                        u"Tyhjä rivi näyttömuotoon",
                        u"Vain näyttömuotoon",
                        u"Tyhjä rivi",
                        u"tyhjä rivi",
                        u"tyhjä rivi ",
                        ]

    for rivi in range(rivi, lopetus + 1):
        sarake = 0
        while(ws.cell(row = rivi, column = sarake).value == None and sarake < 7):
            sarake+=1

        ruutu = ws.cell(row = rivi, column = sarake)
        for count in range(sarake,edellinensarake + 1):
            if(len(stack) > 0):
                stack.pop()
        if(len(stack)>0):
            ollaantkssa = stack[len(stack)-1]
        else:
            ollaantkssa = None
        stack.append(ruutu.value)

        maaritelmasarake = maaritelmaTarkistus(ws)
        esimerkkisarake = esimerkkiTarkistus(ws)
        tiedonesitysmuotosarake = tiedonEsitysmuotoTarkistus(ws)
        huomautussarake = huomautusTarkistus(ws)
        dokumentaatiosarake = dokumentaatioTarkistus(ws)
        toistuvasarake = toistuvaTarkistus(ws)
        pakollinensarake = pakollinenTarkistus(ws)

        maaritelma = ws.cell(row = rivi, column = maaritelmasarake).value
        esimerkki = ws.cell(row = rivi, column = esimerkkisarake).value
        tesruutu = ws.cell(row = rivi, column = tiedonesitysmuotosarake).value
        huomautus = ws.cell(row = rivi, column = huomautussarake).value
        dokumentaatio = ws.cell(row = rivi, column = dokumentaatiosarake).value
        toistuva = ws.cell(row = rivi, column = toistuvasarake).value
        pakollinen = ws.cell(row = rivi, column = pakollinensarake).value
        etsitaan = ruutu.value
        if((etsitaan in ohitettavatLista) == True):
            etsitaan = None
        else:
            etsitaan = ruutu.value
        if((ollaantkssa in ohitettavatLista) == True):
            mista = None
        else:
            mista = ollaantkssa

        xmldoclisaaja(etsitaan, mista, tesruutu, maaritelma, esimerkki, huomautus, dokumentaatio, toistuva, pakollinen, handle, sarake)

        rivi += 1
        edellinensarake = sarake

##Lisää xml-tiedostoon "BusinessInformationEntity"-luokkia
def xmldoclisaaja(etsitaan, mista, tesruutu, maaritelma, esimerkki, huomautus, dokumentaatio, toistuva, pakollinen, handle, sarake):
    if(etsitaan != None and (type(etsitaan) is float) == False):
        etsitaan = etsitaan.replace('TK ', '', 1)
        etsitaan = aakkosiksi(etsitaan)
    if(mista != None and (type(etsitaan) is float) == False):
        mista = mista.replace('TK ', '', 1)
        mista = aakkosiksi(mista)
    if(tesruutu != None and (type(etsitaan) is float) == False):
        tesruutu = tesruutu.replace('TK ', '', 1)
        tesruutu = aakkosiksi(tesruutu)

    if(sarake == 0 and etsitaan != None):
        #ABIE
        dictionaryEntryName = valitpois(etsitaan)
        definition = maaritelma
        label = etsitaan.capitalize()
        objectClassTerm = etsitaan.capitalize()

        xmlLisays = ("<BusinessInformationEntity>\n"
                     "<DictionaryEntryName>"+dictionaryEntryName+"</DictionaryEntryName>\n"#+tesruutu if applicable?
                     ""+("<Definition>"+definition+"</Definition>" if definition != None else "")+"\n"
                     "<Label>"+label+"</Label>\n"
                     "<EntryType>ABIE</EntryType>\n"
                     "<ObjectClassTerm>"+objectClassTerm+"</ObjectClassTerm>\n"
                     "</BusinessInformationEntity>")
                     #+RepresentationTerm = Teksti(tesruutu)+muita kenttiä?
        xmldoc(xmlLisays, handle)
    if(sarake != 0 and etsitaan != None and mista != None):
        #BBIE
        if(mista != None):
            mista = mista.capitalize()
        if(etsitaan != None):
            etsitaan = etsitaan.capitalize()
        if(tesruutu != None):
            tesruutu = tesruutu.capitalize()
        if(toistuva == None):
            mita = u"maxOccurs"
            toistuva = sisallonPaivitys(etsitaan, mista, mita)
            if(toistuva == None):
                toistuva = None
            else:
                if(toistuva == u"1"):
                    toistuva = u"ei"
                elif(toistuva == u"unbounded"):
                    toistuva = u"kyllä"
        if(pakollinen == None):
            mita = u"minOccurs"
            pakollinen = sisallonPaivitys(etsitaan, mista, mita)
            if(pakollinen == None):
                pakollinen = None
            else:
                if(pakollinen == u"0"):
                    pakollinen = u"ei"
                elif(pakollinen == u"1"):
                    pakollinen = u"kyllä"
        if(esimerkki == None):
            mita = u"example"
            esimerkki = sisallonPaivitys(etsitaan, mista, mita)
            if(esimerkki == None):
                esimerkki = None
        if(maaritelma == None):
            mita = u"definition"
            maaritelma = sisallonPaivitys(etsitaan, mista, mita)
            if(maaritelma == None):
                maaritelma = None
        if(huomautus == None):
            mita = u"notice"
            huomautus = sisallonPaivitys(etsitaan, mista, mita)
            if(huomautus == None):
                huomautus = None

        dictionaryEntryName = (valitpois(mista) if mista != None else
                               "")+(valitpois(etsitaan) if etsitaan != None else "")+(tesruutu if tesruutu != None else "")#else "Teksti"?
        definition = maaritelma
        notice = huomautus
        label = etsitaan
        objectClassTerm = (mista if mista != None else "")
        propertyTerm = valitpois(etsitaan)
        representationTerm = tesruutu
        reference = dokumentaatio
        example = esimerkki
        xmlName = (valitpois(etsitaan) if etsitaan != None else "")+(valitpois(tesruutu) if tesruutu != None else "")
        minOccurence = ("1" if pakollinen == "Kyllä" else "0")
        maxOccurence = ("unbounded" if toistuva == "Kyllä" else "1")

        xmlLisays = ("<BusinessInformationEntity>\n"
                     ""+("<DictionaryEntryName>"+dictionaryEntryName+"</DictionaryEntryName>" if dictionaryEntryName != None else "")+"\n"
                     ""+("<Label>"+label+"</Label>" if label != None else "")+"\n"
                     "<EntryType>BBIE</EntryType>\n"
                     ""+("<Definition>"+definition+"</Definition>" if definition != None else "")+"\n"
                     ""+("<Notice>"+notice+"</Notice>" if notice != None else "")+"\n"
                     ""+("<ObjectClassTerm>"+objectClassTerm+"</ObjectClassTerm>" if objectClassTerm != None else "")+"\n"
                     ""+("<PropertyTerm>"+propertyTerm+"</PropertyTerm>" if propertyTerm != None else "")+"\n"
                     ""+("<RepresentationTerm>"+representationTerm+"</RepresentationTerm>" if representationTerm != None else "")+"\n"
                     ""+("<MinOccurence>"+minOccurence+"</MinOccurence>" if minOccurence != None else "")+"\n"
                     ""+("<maxOccurence>"+maxOccurence+"</maxOccurence>" if maxOccurence != None else "")+"\n"
                     ""+("<Reference>KOSO "+str(reference)+"</Reference>" if reference != None else "")+"\n"
                     ""+("<Example>"+example+"</Example>" if example != None else "")+"\n"
                     ""+("<XMLName>"+xmlName+"</XMLName>" if xmlName != None else "")+"\n"
                     "</BusinessInformationEntity>")
        xmldoc(xmlLisays, handle)

##Hakee taulukkoon tyhjien kenttien sisällön.
def sisallonPaivitys(etsitaan, mista, mita):
    try:
        etsitaan = sanaMuunnos(etsitaan)#Muuntaa annetun sanan ääkköset unicode-koodiksi.
        mista = sanaMuunnos(mista)
    except:
        htmlLisays = (u"<h4 class='red'>Rivillä: "+str(rivi+1)+u", Havaittu virhe muutettaessa etsittavän kentän arvoa.</h4>")
        validointi(htmlLisays, handle)
        
    if(mista == None and (type(etsitaan) is float) == False):
        queryString = u"PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> \
                        PREFIX ccts: <http://tikesos.fi/ccts#> \
                        PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> \
                        PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> \
                        select ?"+mita+u" WHERE { \
                        ?any rdfs:label '"+etsitaan+u"'^^xsd:string . \
                        ?any rdf:type ccts:ABIE . \
                        ?any ccts:"+mita+u" ?"+mita+u" }"

        sparql = SPARQLWrapper(u"http://sosmeta.fi:8080/openrdf-sesame/repositories/sosmeta")

        sparql.setQuery(queryString)
        sparql.setMethod(POST)
        sparql.setReturnFormat(XML)
        results = sparql.query().convert()

        for elem in results.getElementsByTagName(u'literal'):
           child = elem.firstChild
           return child.nodeValue

    elif(mista != None and etsitaan != None and (type(etsitaan) is float) == False):
        queryString = u"PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> \
                        PREFIX ccts: <http://tikesos.fi/ccts#> \
                        PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> \
                        PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> \
                        select ?"+mita+u" WHERE { \
                        ?any rdfs:label '"+etsitaan+u"'^^xsd:string . \
                        ?any rdf:type ccts:BBIE . \
                        ?any ccts:hasObjectClassTerm ?upper . \
                        ?upper rdfs:label '"+mista+u"'^^xsd:string . \
                        ?any ccts:"+mita+u" ?"+mita+u" }"

        sparql = SPARQLWrapper(u"http://sosmeta.fi:8080/openrdf-sesame/repositories/sosmeta")

        sparql.setQuery(queryString)
        sparql.setMethod(POST)
        sparql.setReturnFormat(XML)
        results = sparql.query().convert()

        for elem in results.getElementsByTagName(u'literal'):
           child = elem.firstChild
           return child.nodeValue

##Poistaa välilyönnit ja muuntaa jokaisen sanan ensimmäisen kirjaimen isoksi
def valitpois(string):
    uusistring = ""
    string = string.replace("-", " ")
    taulu = string.split()
    for i in range(0, len(taulu)):
        isoksi = taulu[i].capitalize()
        uusistring += isoksi
    return uusistring

##Muuntaa sanan ääkköset aakkosiksi
def aakkosiksi(string):
    string = string.replace(u"ä", "a")
    string = string.replace(u"ö", "o")
    string = string.replace(u"å", "a")
    return string

##Tutkii mistä sarakkeesta löytyy "Määritelmä"-teksti.
def maaritelmaTarkistus(ws):
    sarake = 0
    rivi = 1
    lopetus = u"Määritelmä"
    ruutu = ws.cell(row = rivi, column = sarake)

    while(ruutu.value != lopetus and rivi < 10):
        ruutu = ws.cell(row = rivi, column = sarake)
        sarake +=1
        if(sarake >= 30):
            sarake = 0
            rivi += 1
    
    if(rivi >= 10):
        return -1
    else:
        sarake -= 1
        return sarake

##Tutkii mistä sarakkeesta löytyy "Esimerkki"-teksti.
def esimerkkiTarkistus(ws):
    sarake = 0
    rivi = 1
    lopetus = "Esimerkki"
    ruutu = ws.cell(row = rivi, column = sarake)

    while(ruutu.value != lopetus and rivi < 10):
        ruutu = ws.cell(row = rivi, column = sarake)
        sarake +=1
        if(sarake >= 30):
            sarake = 0
            rivi += 1
    
    if(rivi >= 10):
        return -1
    else:
        sarake -= 1
        return sarake

##Tutkii mistä sarakkeesta löytyy "Huomautus"-teksti.
def huomautusTarkistus(ws):
    sarake = 0
    rivi = 1
    lopetus = "Huomautus"
    ruutu = ws.cell(row = rivi, column = sarake)

    while(ruutu.value != lopetus and rivi < 10):
        ruutu = ws.cell(row = rivi, column = sarake)
        sarake +=1
        if(sarake >= 30):
            sarake = 0
            rivi += 1
    
    if(rivi >= 10):
        return -1
    else:
        sarake -= 1
        return sarake

##Tutkii mistä sarakkeesta löytyy "Dokumentaatio"-teksti.
def dokumentaatioTarkistus(ws):
    sarake = 0
    rivi = 1
    lopetus = "Dokumentaatio"
    ruutu = ws.cell(row = rivi, column = sarake)

    while(ruutu.value != lopetus and rivi < 10):
        ruutu = ws.cell(row = rivi, column = sarake)
        sarake +=1
        if(sarake >= 30):
            sarake = 0
            rivi += 1
    
    if(rivi >= 10):
        return -1
    else:
        sarake -= 1
        return sarake

##Tutkii mistä sarakkeesta löytyy "Tiedon esitysmuoto"-teksti.
def tiedonEsitysmuotoTarkistus(ws):
    sarake = 0
    rivi = 1
    lopetus = "Tiedon esitysmuoto"
    ruutu = ws.cell(row = rivi, column = sarake)

    while(ruutu.value != lopetus and rivi < 10):
        ruutu = ws.cell(row = rivi, column = sarake)
        sarake +=1
        if(sarake >= 30):
            sarake = 0
            rivi += 1
    if(rivi >= 10):
        return -1
    else:
        sarake -= 1
        return sarake

##Tutkii mistä sarakkeesta löytyy "Toistuva"-teksti.
def toistuvaTarkistus(ws):
    sarake = 0
    rivi = 1
    lopetus = "Toistuva"
    ruutu = ws.cell(row = rivi, column = sarake)

    while(ruutu.value != lopetus and rivi < 10):
        ruutu = ws.cell(row = rivi, column = sarake)
        sarake +=1
        if(sarake >= 30):
            sarake = 0
            rivi += 1
    
    if(rivi >= 10):
        return -1
    else:
        sarake -= 1
        return sarake

##Tutkii mistä sarakkeesta löytyy "Pakollinen"-teksti.
def pakollinenTarkistus(ws):
    sarake = 0
    rivi = 1
    lopetus = "Pakollinen"
    ruutu = ws.cell(row = rivi, column = sarake)
    oletus = 15

    while(ruutu.value != lopetus and rivi < 10):
        ruutu = ws.cell(row = rivi, column = sarake)
        sarake +=1
        if(sarake >= 30):
            sarake = 0
            rivi += 1

    if(rivi >= 10):
        return -1
    else:
        sarake -= 1
        return sarake

##Tulostaa pinon
def tulostaLista(lista):
    for i in lista:
        for j in i.values():
            for e in j:
                print i.keys(), e

##Etsii taulukosta määrätyillä arvoilla viimeisen rivin
def viimeinenRiviTaulukossa(ws):
    rivi = 0
    etsittava = "Versiohistoria"
    etsittava2 = "Versiohistoria:"

    try:
        while(ws.cell(row = rivi, column = 0).value != etsittava and ws.cell(row = rivi, column = 0).value != etsittava2):
            rivi += 1
            if(rivi >= 1000):
                print "Versiohistoria-kenttää ei löydy!"
                raise ValueError
    except ValueError:
        rivi = 0
        try:
            while((type(ws.cell(row = rivi, column = 0).value) is float) == False):
                rivi += 1
                if(rivi >= 1000):
                    print "Versiohistorian numerointia ei löytynyt ensimmäisestä sarakkeesta!"
                    raise TypeError
        except TypeError:
            rivi = 0
            try:
                while((type(ws.cell(row = rivi, column = 1).value) is float) == False):
                    rivi += 1
                    if(rivi >= 1000):
                        raise NameError
            except NameError:
                print "Versiohistorian numerointia ei löydy!"

    tiedonesitysmuoto = tiedonEsitysmuotoTarkistus(ws)
    tyhjarivi = True
    while(tyhjarivi == True):
        rivi -= 1
        sarake = 0
        for sarake in range(0, tiedonesitysmuoto):
            if(ws.cell(row = rivi, column = sarake).value != None):
                tyhjarivi = False
    return rivi

##Muuntaa annetun sanan ääkköset unicode-koodiksi
def sanaMuunnos(string):
    if(string != None):
        string = string.replace(u'ä', '\u00E4')
        string = string.replace(u'ö', '\u00F6')
        return string

##poistaa ylimääräiset välit
def valinPoisto(string):
    if(string != None):
        muunnettu = ""
        taulu = string.split()
        for i in range(0, len(taulu)):
            muunnettu += taulu[i]+" "
        string = muunnettu.strip()
    return string


main()
